package com.eralink.uhfreaderlib;

public class EraLinkUHFReaderInterface {
    private ProcessCenter processCenter = null;

    public EraLinkUHFReaderInterface() {
        processCenter = new ProcessCenter();
    }

    public int connect(String connect_str, EraLinkUHFReaderReportCallback reportCallback) {
        return processCenter.connect(connect_str, reportCallback);
    }

    public int listen(String listen_ip, short listen_port, EraLinkUHFReaderReportCallback reportCallback) {
        return processCenter.listen(listen_ip, listen_port, reportCallback);
    }

    public int close() {
        return processCenter.close();
    }

    public int removeReader(byte reader_id) {
        return processCenter.removeReader(reader_id);
    }

    public int setMacAddress(byte reader_id, final byte[] mac_address) {
        return processCenter.setMacAddress(reader_id, mac_address);
    }

    public int getSN(byte reader_id, final String[] sn) {
        return processCenter.getSN(reader_id, sn);
    }

    public int setHeartbeatInterval(byte reader_id, byte interval) {
        return processCenter.setHeartbeatInterval(reader_id, interval);
    }

    public int heartbeat(byte reader_id) {
        return processCenter.heartbeat(reader_id);
    }

    public int getInventoryStatistics(byte reader_id, final byte[] statistics, final int[] statistics_len) {
        return processCenter.getInventoryStatistics(reader_id, statistics, statistics_len);
    }

    public int blockWrite(byte reader_id, byte bank, short offset, byte length, final byte[] access_password, final byte[] tag_data) {
        return processCenter.blockWrite(reader_id, bank, offset, length, access_password, tag_data);
    }

    public int blockErase(byte reader_id, byte bank, short offset, byte length, final byte[] access_password) {
        return processCenter.blockErase(reader_id, bank, offset, length, access_password);
    }

    public int inventoryOnce(byte reader_id) {
        return processCenter.inventoryOnce(reader_id);
    }

    public int readTag(byte reader_id, byte bank, short offset, byte length, final byte[] access_password, final byte[] tag_data) {
        return processCenter.readTag(reader_id, bank, offset, length, access_password, tag_data);
    }

    public int writeTag(byte reader_id, byte bank, short offset, byte length, final byte[] access_password, final byte[] tag_data) {
        return processCenter.writeTag(reader_id, bank, offset, length, access_password, tag_data);
    }

    public int getAntEchoDetectingParams(byte reader_id, final byte[] ant_echo_detecting_params, final int[] ant_echo_detecting_params_len) {
        return processCenter.getAntEchoDetectingParams(reader_id, ant_echo_detecting_params, ant_echo_detecting_params_len);
    }

    public int inventory(byte reader_id) {
        return processCenter.inventory(reader_id);
    }

    public int stopInventory(byte reader_id) {
        return processCenter.stopInventory(reader_id);
    }

    public int lockTag(byte reader_id, byte lock_type, byte bank, final byte[] access_password) {
        return processCenter.lockTag(reader_id, lock_type, bank, access_password);
    }

    public int killTag(byte reader_id, final byte[] kill_password, final byte[] access_password) {
        return processCenter.killTag(reader_id, kill_password, access_password);
    }

    public int startAutoRead(byte reader_id) {
        return processCenter.startAutoRead(reader_id);
    }

    public int stopAutoRead(byte reader_id) {
        return processCenter.stopAutoRead(reader_id);
    }

    public int upgrade(byte reader_id, final byte[] data) {
        return processCenter.upgrade(reader_id, data);
    }

    public int getFirmwareVersion(byte reader_id, final String[] version) {
        return processCenter.getFirmwareVersion(reader_id, version);
    }

    public int getAntConfig(byte reader_id, final byte[] ant_config, final int[] ant_config_len) {
        return processCenter.getAntConfig(reader_id, ant_config, ant_config_len);
    }

    public int setAntConfig(byte reader_id, final byte[] ant_config) {
        return processCenter.setAntConfig(reader_id, ant_config);
    }

    public int getGpioTriggerStatus(byte reader_id, final byte[] statuses, final int[] statuses_len) {
        return processCenter.getGpioTriggerStatus(reader_id, statuses, statuses_len);
    }

    public int setRelayStatus(byte reader_id, byte relay_number, byte relay_status) {
        return processCenter.setRelayStatus(reader_id, relay_number, relay_status);
    }

    public int setQValue(byte reader_id, byte mode, byte start_q_value, byte max_q_value,
                         byte min_q_value, byte threshold_multiplier) {
        return processCenter.setQValue(reader_id, mode, start_q_value, max_q_value, min_q_value, threshold_multiplier);
    }

    public int getQValue(byte reader_id, final byte[] mode, final byte[] start_q_value, final byte[] max_q_value,
                         final byte[] min_q_value, final byte[] threshold_multiplier) {
        return processCenter.getQValue(reader_id, mode, start_q_value, max_q_value, min_q_value, threshold_multiplier);
    }

    public int setQueryConfig(byte reader_id, byte query_target, byte query_session, byte query_select) {
        return processCenter.setQueryConfig(reader_id, query_target, query_session, query_select);
    }

    public int getQueryConfig(byte reader_id, final byte[] query_target, final byte[] query_session, final byte[] query_select) {
        return processCenter.getQueryConfig(reader_id, query_target, query_session, query_select);
    }

    public int setInventoryConfig(byte reader_id, byte inventory_algorithm, byte match_report,
                                  byte auto_select, byte disable_inventory) {
        return processCenter.setInventoryConfig(reader_id, inventory_algorithm, match_report, auto_select, disable_inventory);
    }

    public int getInventoryConfig(byte reader_id, final byte[] inventory_algorithm, final byte[] match_report,
                                  final byte[] auto_select, final byte[] disable_inventory) {
        return processCenter.getInventoryConfig(reader_id, inventory_algorithm, match_report, auto_select, disable_inventory);
    }

    public int setTxOnOffTime(byte reader_id, byte mode, short tx_on_time, short tx_off_time) {
        return processCenter.setTxOnOffTime(reader_id, mode, tx_on_time, tx_off_time);
    }

    public int getTxOnOffTime(byte reader_id, final byte[] mode, final short[] tx_on_time, final short[] tx_off_time) {
        return processCenter.getTxOnOffTime(reader_id, mode, tx_on_time, tx_off_time);
    }

    public int setAdjustCwConfig(byte reader_id, byte adjust_time) {
        return processCenter.setAdjustCwConfig(reader_id, adjust_time);
    }

    public int getAdjustCwConfig(byte reader_id, final byte[] adjust_time) {
        return processCenter.getAdjustCwConfig(reader_id, adjust_time);
    }

    public int getReaderState(byte reader_id) {
        return processCenter.getReaderState(reader_id);
    }

    public int readMacRegister(byte reader_id, int address, final int[] value) {
        return processCenter.readMacRegister(reader_id, address, value);
    }

    public int writeMacRegister(byte reader_id, int address, int value) {
        return processCenter.writeMacRegister(reader_id, address, value);
    }

    public int readOemRegister(byte reader_id, int address, final int[] value) {
        return processCenter.readOemRegister(reader_id, address, value);
    }

    public int writeOemRegister(byte reader_id, int address, int value) {
        return processCenter.writeOemRegister(reader_id, address, value);
    }

    public int writeOemRegisterWithoutReset(byte reader_id, int address, int value) {
        return processCenter.writeOemRegisterWithoutReset(reader_id, address, value);
    }

    public int setLinkProfile(byte reader_id, byte link_profile) {
        return processCenter.setLinkProfile(reader_id, link_profile);
    }

    public int getLinkProfile(byte reader_id, final byte[] link_profile) {
        return processCenter.getLinkProfile(reader_id, link_profile);
    }

    public int resetUHF(byte reader_id) {
        return processCenter.resetUHF(reader_id);
    }

    public int resetReader(byte reader_id) {
        return processCenter.resetReader(reader_id);
    }

    public int switchCarrierWave(byte reader_id, byte toggle) {
        return processCenter.switchCarrierWave(reader_id, toggle);
    }

    public int switchHopping(byte reader_id, byte toggle, byte channel_index) {
        return processCenter.switchHopping(reader_id, toggle, channel_index);
    }

    public int setTestFrequency(byte reader_id, int frequency) {
        return processCenter.setTestFrequency(reader_id, frequency);
    }

    public int setTestAntPower(byte reader_id, byte ant, int power) {
        return processCenter.setTestAntPower(reader_id, ant, power);
    }

    public int selectTag(byte reader_id, byte bank, short offset, short length, final byte[] tag_data) {
        return processCenter.selectTag(reader_id, bank, offset, length, tag_data);
    }

    public int cancelSelectTag(byte reader_id) {
        return processCenter.cancelSelectTag(reader_id);
    }

    public int getSelectTag(byte reader_id, final byte[] select_tag, final int[] select_tag_len) {
        return processCenter.getSelectTag(reader_id, select_tag, select_tag_len);
    }

    public int startMultiBankAutoRead(byte reader_id, final byte[] params) {
        return processCenter.startMultiBankAutoRead(reader_id, params);
    }

    public int stopMultiBankAutoRead(byte reader_id) {
        return processCenter.stopMultiBankAutoRead(reader_id);
    }

    public int getDeviceName(byte reader_id, final String[] device_name) {
        return processCenter.getDeviceName(reader_id, device_name);
    }

    public int setDeviceName(byte reader_id, String device_name) {
        return processCenter.setDeviceName(reader_id, device_name);
    }

    public int setWorkMode(byte reader_id, byte work_mode) {
        return processCenter.setWorkMode(reader_id, work_mode);
    }

    public int setCommunicationMode(byte reader_id, byte communication_mode) {
        return processCenter.setCommunicationMode(reader_id, communication_mode);
    }

    public int setRs485Address(byte reader_id, byte rs485_address) {
        return processCenter.setRs485Address(reader_id, rs485_address);
    }

    public int setTriggerModeDelayStopReadTime(byte reader_id, byte time) {
        return processCenter.setTriggerModeDelayStopReadTime(reader_id, time);
    }

    public int setAutoReadParams(byte reader_id, byte bank, short offset, byte length, final byte[] access_password) {
        return processCenter.setAutoReadParams(reader_id, bank, offset, length, access_password);
    }

    public int setRssiFilter(byte reader_id, byte enable, short rssi_value) {
        return processCenter.setRssiFilter(reader_id, enable, rssi_value);
    }

    public int setTagFilter(byte reader_id, byte enable, byte filter_time) {
        return processCenter.setTagFilter(reader_id, enable, filter_time);
    }

    public int setWifiParams(byte reader_id, byte index, String params) {
        return processCenter.setWifiParams(reader_id, index, params);
    }

    public int setGprsParams(byte reader_id, byte index, String params) {
        return processCenter.setGprsParams(reader_id, index, params);
    }

    public int setBuzzerEnable(byte reader_id, byte enable) {
        return processCenter.setBuzzerEnable(reader_id, enable);
    }

    public int setBaud(byte reader_id, int baud) {
        return processCenter.setBaud(reader_id, baud);
    }

    public int setWgParams(byte reader_id, byte protocol_type, byte position, byte pulse_width, byte pulse_cycle, byte data_interval) {
        return processCenter.setWgParams(reader_id, protocol_type, position, pulse_width, pulse_cycle, data_interval);
    }

    public int setRtcTime(byte reader_id, final byte[] rtc_time) {
        return processCenter.setRtcTime(reader_id, rtc_time);
    }

    public int getWorkMode(byte reader_id, final byte[] work_mode) {
        return processCenter.getWorkMode(reader_id, work_mode);
    }

    public int getCommunicationMode(byte reader_id, final byte[] communication_mode) {
        return processCenter.getCommunicationMode(reader_id, communication_mode);
    }

    public int getRs485Address(byte reader_id, final byte[] rs485_address) {
        return processCenter.getRs485Address(reader_id, rs485_address);
    }

    public int getTriggerModeDelayStopReadTime(byte reader_id, final byte[] time) {
        return processCenter.getTriggerModeDelayStopReadTime(reader_id, time);
    }

    public int getAutoReadParams(byte reader_id, final byte[] bank, final short[] offset, final byte[] length,
                                 final byte[] access_password) {
        return processCenter.getAutoReadParams(reader_id, bank, offset, length, access_password);
    }

    public int getRssiFilter(byte reader_id, final byte[] enable, final short[] rssi_value) {
        return processCenter.getRssiFilter(reader_id, enable, rssi_value);
    }

    public int getTagFilter(byte reader_id, final byte[] enable, final byte[] filter_time) {
        return processCenter.getTagFilter(reader_id, enable, filter_time);
    }

    public int getWifiParams(byte reader_id, byte index, final String[] params) {
        return processCenter.getWifiParams(reader_id, index, params);
    }

    public int getGprsParams(byte reader_id, byte index, final String[] params) {
        return processCenter.getGprsParams(reader_id, index, params);
    }

    public int getBuzzerEnable(byte reader_id, final byte[] enable) {
        return processCenter.getBuzzerEnable(reader_id, enable);
    }

    public int getBaud(byte reader_id, final int[] baud) {
        return processCenter.getBaud(reader_id, baud);
    }

    public int getWgParams(byte reader_id, final byte[] protocol_type, final byte[] data_start_address,
                           final byte[] pulse_width, final byte[] pulse_cycle, final byte[] data_interval) {
        return processCenter.getWgParams(reader_id, protocol_type, data_start_address, pulse_width, pulse_cycle, data_interval);
    }

    public int getRtcTime(byte reader_id, final byte[] rtc_time) {
        return processCenter.getRtcTime(reader_id, rtc_time);
    }

    public int getAllSystemParams(byte reader_id, final byte[] system_params, final int[] system_params_len) {
        return processCenter.getAllSystemParams(reader_id, system_params, system_params_len);
    }
}
